{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PPO实现CarPole-v1（离散动作空间）\n",
    "#### 参考：https://huggingface.co/blog/deep-rl-ppo\n",
    "\n",
    "原始PG算法为同策略算法，即“收集一次轨迹更新一回合参数”，之后就需要重新收集轨迹，非常浪费时间和资源。在这种情况下，可以采用一个演员参数$\\theta_{k}$来和环境交互收集经验，利用另一个参数$\\theta$来更新策略。\n",
    "\n",
    "PPO算法的本质是**根据优势函数的值来判断一个策略表现是否良好**，当策略训练好后无论输入哪个状态都可以给出最佳的动作概率分布。\n",
    "\n",
    "#### 修正项引入\n",
    "1. 为修正不同采样概率带来的偏差，**在损失函数中引入重要性采样参数**；\n",
    "2. 如果两个参数采样方差过大（这里参考《强化学习教程》PPO章节，给出了一个两个采样参数差距过大的例子）会导致过大的pi(a|s)概率方差。因为即使引入了重要性权重参数，**在采样不完全的情况下两个方差很大的参数采样得到的数据方差会很大**，于是这里引入裁剪函数修正二者过大的方差。\n",
    "\n",
    "原始的损失函数为：$$Loss(\\theta)=(G-V(s;\\theta^{V}))ln\\pi(A|S;\\theta)$$\n",
    "PPO-clip算法修改损失函数为：$$Loss(\\theta)=min(\\frac{\\pi_{\\theta}(a|s)}{\\pi_{\\theta_{k}}(a|s)}A^{\\pi_{\\theta_{k}}}(s,a),g(\\epsilon,A^{\\pi_{\\theta_{k}}}(s,a)))$$\n",
    "其中，\n",
    "$$g(\\epsilon,A^{\\pi_{\\theta_{k}}}(s,a))=\\begin{cases}\n",
    "(1+\\epsilon)A, &A\\ge0 \\\\\n",
    "(1-\\epsilon)A, &A\\le0\n",
    "\\end{cases}\n",
    "$$\n",
    "状态价值函数的损失函数为：$$Loss(\\theta^{V})=\\frac{1}{2}(G_{t}-V(s_{t};\\theta^{V}))^{2}$$\n",
    "根据损失函数进行讨论，设重要性权重为x：\n",
    "1. 若动作a是一个良好的动作，A>0，此时应该增大选择a的概率：\n",
    "   \n",
    "   a. 如果x<1+$\\epsilon$，说明此时两个参数差距尚且不大，可以向梯度增加的方向进行更新；\n",
    "   \n",
    "   b. 如果x>1+$\\epsilon$，说明此时两个参数差距较大，不进行梯度更新；\n",
    "2. 若动作a是一个不好的动作，A<0，此时应该减小选择a的概率：\n",
    "   \n",
    "   a. 如果x<1-$\\epsilon$，说明此时两个参数差距较大，不进行梯度更新；\n",
    "\n",
    "   b. 如果x>1-$\\epsilon$，说明此时两个参数差距尚且不大，可以向梯度减小的方向进行更新；"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 定义算法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 定义模型\n",
    "\n",
    "actor网络输出的是一个一维矩阵，每一个元素标明着输出动作的概率；critic网络输出的是一个标量。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class ActorSoftmax(nn.Module):\n",
    "    def __init__(self, input_dim, output_dim, hidden_dim=256):\n",
    "        super(ActorSoftmax, self).__init__()\n",
    "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.fc3 = nn.Linear(hidden_dim, output_dim)\n",
    "    def forward(self,x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        probs = F.softmax(self.fc3(x),dim=1)#shape(hidden_dim,n_actions)，指定第几维的参数参与softmax运算\n",
    "        #返回值是一个一维矩阵，标明着每一个动作的执行概率\n",
    "        return probs\n",
    "class Critic(nn.Module):\n",
    "    def __init__(self,input_dim,output_dim,hidden_dim=256):\n",
    "        super(Critic,self).__init__()\n",
    "        #价值网络，输出是一个标量\n",
    "        #A(s,a)=G-V(s)\n",
    "        assert output_dim == 1 # critic must output a single value\n",
    "        self.fc1 = nn.Linear(input_dim, hidden_dim)\n",
    "        self.fc2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.fc3 = nn.Linear(hidden_dim, output_dim)\n",
    "    def forward(self,x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        x = F.relu(self.fc2(x))\n",
    "        value = self.fc3(x)\n",
    "        return value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 定义经验回放\n",
    "\n",
    "经验回放采样要顺序采样，不可随机采样。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "from collections import deque\n",
    "class ReplayBufferQue:\n",
    "    '''DQN的经验回放池，每次采样batch_size个样本'''\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        '''_summary_\n",
    "        Args:\n",
    "            trainsitions (tuple): _description_\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer):\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # sequential sampling\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else:\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)\n",
    "\n",
    "class PGReplay(ReplayBufferQue):\n",
    "    '''PG的经验回放池，每次采样所有样本，因此只需要继承ReplayBufferQue，重写sample方法即可\n",
    "    '''\n",
    "    def __init__(self):\n",
    "        self.buffer = deque()\n",
    "    def sample(self):\n",
    "        ''' sample all the transitions\n",
    "        '''\n",
    "        batch = list(self.buffer)\n",
    "        return zip(*batch)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.3 定义智能体"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "from torch.distributions import Categorical\n",
    "class Agent:\n",
    "    def __init__(self,cfg) -> None:\n",
    "        \n",
    "        self.gamma = cfg.gamma\n",
    "        self.device = torch.device(cfg.device) \n",
    "        self.actor = ActorSoftmax(cfg.n_states,cfg.n_actions, hidden_dim = cfg.actor_hidden_dim).to(self.device)\n",
    "        self.critic = Critic(cfg.n_states,1,hidden_dim=cfg.critic_hidden_dim).to(self.device)\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=cfg.actor_lr)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=cfg.critic_lr)\n",
    "        self.memory = PGReplay()\n",
    "        self.k_epochs = cfg.k_epochs # update policy for K epochs\n",
    "        self.eps_clip = cfg.eps_clip # clip parameter for PPO\n",
    "        self.entropy_coef = cfg.entropy_coef # entropy coefficient\n",
    "        self.sample_count = 0\n",
    "        self.update_freq = cfg.update_freq\n",
    "\n",
    "    def sample_action(self,state):\n",
    "        '''\n",
    "        将(batch_size,state)的矩阵作为参数放入actor网络获得每个动作的输出概率\n",
    "        根据概率进行抽样得到动作\n",
    "        '''\n",
    "        self.sample_count += 1\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        probs = self.actor(state)#概率尚未归一化\n",
    "        dist = Categorical(probs)#根据probs概率生成张量表示一个分布，shape[0,..,shape(probs,dim=1)]，每一个元素是动作的概率\n",
    "        action = dist.sample()#从dist中抽样1次，返回值是索引\n",
    "        self.log_probs = dist.log_prob(action).detach()#计算某一个动作的概率的对数，一定要取detach不参与梯度更新\n",
    "        return action.detach().cpu().numpy().item()#返回值为动作的索引值\n",
    "    @torch.no_grad()\n",
    "    def predict_action(self,state):\n",
    "        '''\n",
    "        将(1,state)的矩阵作为参数放入actor网络获得每个动作的输出概率\n",
    "        根据概率进行抽样得到动作\n",
    "        '''\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        probs = self.actor(state)\n",
    "        dist = Categorical(probs)\n",
    "        action = dist.sample()\n",
    "        return action.detach().cpu().numpy().item()\n",
    "    def update(self):\n",
    "        # update policy every n steps\n",
    "        # 每经过self.update_freq步更新一次\n",
    "        if self.sample_count % self.update_freq != 0:\n",
    "            return\n",
    "        # print(\"update policy\")\n",
    "\n",
    "        #将当前buffer中的所有经验采样出来\n",
    "        old_states, old_actions, old_log_probs, old_rewards, old_dones = self.memory.sample()\n",
    "        # convert to tensor\n",
    "        old_states = torch.tensor(np.array(old_states), device=self.device, dtype=torch.float32) #shape(buffer_size,n_states=4)\n",
    "        old_actions = torch.tensor(np.array(old_actions), device=self.device, dtype=torch.float32)#shape(buffer_size,n_actions=1)\n",
    "        old_log_probs = torch.tensor(old_log_probs, device=self.device, dtype=torch.float32)#shape(buffer_size,1)\n",
    "        # monte carlo estimate of state rewards\n",
    "        returns = []\n",
    "        discounted_sum = 0\n",
    "        '''\n",
    "        倒序求期望回报\n",
    "        设初始奖励序列为(R_i,R_i+1,...,R_T+i)\n",
    "        结束时期望回报序列为(G_i,G_i+1,...,G_T+i)\n",
    "        当序列中存在终止状态时结果仍不变\n",
    "        '''\n",
    "        for reward, done in zip(reversed(old_rewards), reversed(old_dones)):\n",
    "            if done:#buffer中可能有多个结束状态，此时重置期望回报\n",
    "                discounted_sum = 0\n",
    "            discounted_sum = reward + (self.gamma * discounted_sum)\n",
    "            #倒序插入\n",
    "            returns.insert(0, discounted_sum)\n",
    "        # Normalizing the rewards:\n",
    "        #蒙特卡洛法获得的期望回报方差过大，需要归一化消除奇异值影响\n",
    "        returns = torch.tensor(returns, device=self.device, dtype=torch.float32)\n",
    "        returns = (returns - returns.mean()) / (returns.std() + 1e-5) # 1e-5 to avoid division by zero\n",
    "        # 利用同一批数据训练k_epochs次\n",
    "        for _ in range(self.k_epochs):\n",
    "            # compute advantage\n",
    "            values = self.critic(old_states) # detach to avoid backprop through the critic\n",
    "            advantage = returns - values.detach()\n",
    "            # get action probabilities\n",
    "            # theta每更新一次需要重新建立pi(a|s)分布\n",
    "            probs = self.actor(old_states)\n",
    "            dist = Categorical(probs)#按照动作的索引建立分布(a0_prob,a1_prob,...,aEnd_prob)\n",
    "            # get new action probabilities\n",
    "            # 这里为什么不直接通过动作的索引取概率？因为dist.probs张量不支持向量化取值\n",
    "            new_probs = dist.log_prob(old_actions)#根据原动作索引计算新的概率对数\n",
    "            # compute ratio (pi_theta / pi_theta__old)\n",
    "            ratio = torch.exp(new_probs - old_log_probs) # old_log_probs must be detached\n",
    "            # compute surrogate loss\n",
    "            surr1 = ratio * advantage\n",
    "            surr2 = torch.clamp(ratio, 1 - self.eps_clip, 1 + self.eps_clip) * advantage\n",
    "            # compute actor loss\n",
    "            actor_loss = -torch.min(surr1, surr2).mean() + self.entropy_coef * dist.entropy().mean()\n",
    "            # compute critic loss\n",
    "            critic_loss = (returns - values).pow(2).mean()\n",
    "            # take gradient step\n",
    "            self.actor_optimizer.zero_grad()\n",
    "            self.critic_optimizer.zero_grad()\n",
    "            actor_loss.backward()\n",
    "            critic_loss.backward()\n",
    "            self.actor_optimizer.step()#theta参数需要更新\n",
    "            self.critic_optimizer.step()#价值函数估计网络需要更新\n",
    "        self.memory.clear()#每更新一次则清空旧的经验"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 定义训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "def train(cfg, env, agent):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    print(\"开始训练！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    best_ep_reward = 0 # 记录最大回合奖励\n",
    "    output_agent = None\n",
    "    for i_ep in range(cfg.train_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step += 1\n",
    "            action = agent.sample_action(state)  # 选择动作\n",
    "            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition\n",
    "            #将(s,a,log_probs,r,done)保存至回放池中\n",
    "            #log_probs表示执行动作的对数概率，即lnpi(a|s)\n",
    "            agent.memory.push((state, action,agent.log_probs,reward,done))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            agent.update()  # 更新智能体\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "\n",
    "        #评估\n",
    "        if (i_ep+1)%cfg.eval_per_episode == 0:\n",
    "            sum_eval_reward = 0\n",
    "            for _ in range(cfg.eval_eps):\n",
    "                eval_ep_reward = 0\n",
    "                state = env.reset()\n",
    "                for _ in range(cfg.max_steps):\n",
    "                    action = agent.predict_action(state)  # 选择动作\n",
    "                    next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition\n",
    "                    state = next_state  # 更新下一个状态\n",
    "                    eval_ep_reward += reward  # 累加奖励\n",
    "                    if done:\n",
    "                        break\n",
    "                sum_eval_reward += eval_ep_reward\n",
    "            mean_eval_reward = sum_eval_reward/cfg.eval_eps\n",
    "            if mean_eval_reward >= best_ep_reward:\n",
    "                best_ep_reward = mean_eval_reward\n",
    "                output_agent = copy.deepcopy(agent)\n",
    "                print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，评估奖励：{mean_eval_reward:.2f}，最佳评估奖励：{best_ep_reward:.2f}，更新模型！\")\n",
    "            else:\n",
    "                print(f\"回合：{i_ep+1}/{cfg.train_eps}，奖励：{ep_reward:.2f}，评估奖励：{mean_eval_reward:.2f}，最佳评估奖励：{best_ep_reward:.2f}\")\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "    print(\"完成训练！\")\n",
    "    env.close()\n",
    "    return output_agent,{'rewards':rewards}\n",
    "\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []\n",
    "    for i_ep in range(cfg.test_eps):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state = env.reset()  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_steps):\n",
    "            ep_step+=1\n",
    "            action = agent.predict_action(state)  # 选择动作\n",
    "            next_state, reward, done, _ = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if done:\n",
    "                break\n",
    "        steps.append(ep_step)\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg.test_eps}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import os\n",
    "import numpy as np\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = gym.make(cfg.env_name) # 创建环境\n",
    "    all_seed(env,seed=cfg.seed)\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.n\n",
    "    print(f\"状态空间维度：{n_states}，动作空间维度：{n_actions}\")\n",
    "    # 更新n_states和n_actions到cfg参数中\n",
    "    setattr(cfg, 'n_states', n_states)\n",
    "    setattr(cfg, 'n_actions', n_actions) \n",
    "    agent = Agent(cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "class Config:\n",
    "    def __init__(self) -> None:\n",
    "        self.env_name = \"CartPole-v1\" # 环境名字\n",
    "        self.new_step_api = False # 是否用gym的新api\n",
    "        self.algo_name = \"PPO\" # 算法名字\n",
    "        self.mode = \"train\" # train or test\n",
    "        self.seed = 1 # 随机种子\n",
    "        self.device = \"cuda\" # device to use\n",
    "        self.train_eps = 200 # 训练的回合数\n",
    "        self.test_eps = 20 # 测试的回合数\n",
    "        self.max_steps = 200 # 每个回合的最大步数\n",
    "        self.eval_eps = 5 # 评估的回合数\n",
    "        self.eval_per_episode = 10 # 评估的频率\n",
    "\n",
    "        self.gamma = 0.99 # 折扣因子\n",
    "        self.k_epochs = 4 # 更新策略网络的次数\n",
    "        self.actor_lr = 0.0003 # actor网络的学习率\n",
    "        self.critic_lr = 0.0003 # critic网络的学习率\n",
    "        self.eps_clip = 0.2 # epsilon-clip\n",
    "        self.entropy_coef = 0.01 # entropy的系数\n",
    "        self.update_freq = 100 # 更新频率\n",
    "        self.actor_hidden_dim = 256 # actor网络的隐藏层维度\n",
    "        self.critic_hidden_dim = 256 # critic网络的隐藏层维度\n",
    "\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,cfg, tag='train'):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{tag}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_name}\")\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 开始训练"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "状态空间维度：4，动作空间维度：2\n",
      "开始训练！\n",
      "回合：10/200，奖励：11.00，评估奖励：29.20，最佳评估奖励：29.20，更新模型！\n",
      "回合：20/200，奖励：68.00，评估奖励：25.00，最佳评估奖励：29.20\n",
      "回合：30/200，奖励：60.00，评估奖励：26.20，最佳评估奖励：29.20\n",
      "回合：40/200，奖励：105.00，评估奖励：27.60，最佳评估奖励：29.20\n",
      "回合：50/200，奖励：26.00，评估奖励：60.60，最佳评估奖励：60.60，更新模型！\n",
      "回合：60/200，奖励：122.00，评估奖励：113.40，最佳评估奖励：113.40，更新模型！\n",
      "回合：70/200，奖励：65.00，评估奖励：38.00，最佳评估奖励：113.40\n",
      "回合：80/200，奖励：175.00，评估奖励：135.40，最佳评估奖励：135.40，更新模型！\n",
      "回合：90/200，奖励：200.00，评估奖励：177.20，最佳评估奖励：177.20，更新模型！\n",
      "回合：100/200，奖励：115.00，评估奖励：173.60，最佳评估奖励：177.20\n",
      "回合：110/200，奖励：200.00，评估奖励：183.20，最佳评估奖励：183.20，更新模型！\n",
      "回合：120/200，奖励：196.00，评估奖励：173.60，最佳评估奖励：183.20\n",
      "回合：130/200，奖励：46.00，评估奖励：61.40，最佳评估奖励：183.20\n",
      "回合：140/200，奖励：200.00，评估奖励：166.40，最佳评估奖励：183.20\n",
      "回合：150/200，奖励：172.00，评估奖励：154.40，最佳评估奖励：183.20\n",
      "回合：160/200，奖励：61.00，评估奖励：84.80，最佳评估奖励：183.20\n",
      "回合：170/200，奖励：127.00，评估奖励：181.60，最佳评估奖励：183.20\n",
      "回合：180/200，奖励：152.00，评估奖励：173.20，最佳评估奖励：183.20\n",
      "回合：190/200，奖励：200.00，评估奖励：200.00，最佳评估奖励：200.00，更新模型！\n",
      "回合：200/200，奖励：176.00，评估奖励：190.20，最佳评估奖励：200.00\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/20，奖励：200.00\n",
      "回合：2/20，奖励：200.00\n",
      "回合：3/20，奖励：200.00\n",
      "回合：4/20，奖励：200.00\n",
      "回合：5/20，奖励：200.00\n",
      "回合：6/20，奖励：200.00\n",
      "回合：7/20，奖励：200.00\n",
      "回合：8/20，奖励：200.00\n",
      "回合：9/20，奖励：200.00\n",
      "回合：10/20，奖励：200.00\n",
      "回合：11/20，奖励：200.00\n",
      "回合：12/20，奖励：200.00\n",
      "回合：13/20，奖励：200.00\n",
      "回合：14/20，奖励：200.00\n",
      "回合：15/20，奖励：200.00\n",
      "回合：16/20，奖励：200.00\n",
      "回合：17/20，奖励：200.00\n",
      "回合：18/20，奖励：200.00\n",
      "回合：19/20，奖励：200.00\n",
      "回合：20/20，奖励：200.00\n",
      "完成测试\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = Config() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "best_agent,res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"train\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, best_agent)\n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"test\")  # 画出结果"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.12 ('easyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.10"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "f5a9629e9f3b9957bf68a43815f911e93447d47b3d065b6a8a04975e44c504d9"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
